import { useState, useRef, useCallback, useEffect } from 'react';
import { useTranslation } from 'react-i18next';
import {
  VoiceRecognitionStatus,
  VoiceRecognitionResult,
  UseVoiceRecognitionReturn,
  VoiceSignatureResponse
} from '../types/speechRecognition';
import {
  getVoiceSignature,
  isSignatureValid,
  createVoiceRecognitionWebSocket
} from '../api/speechRecognitionAPI';
import { AudioRecorder, AudioCompatibility } from '../utils/audioUtils';

/**
 * 腾讯云语音识别Hook
 * 
 * 功能特性：
 * - 实时语音转文字
 * - 自动签名管理和刷新
 * - 音频录制和格式转换
 * - 错误处理和重连机制
 * - 浏览器兼容性检查
 * 
 * @param options 配置选项
 * @returns 语音识别相关状态和方法
 */



export const useVoiceRecognition = (options: {
  userId?: number;
  engineType?: string;
  autoStart?: boolean;
  onResult?: (result: VoiceRecognitionResult) => void;
  onError?: (error: string) => void;
} = {}): UseVoiceRecognitionReturn => {
  const { t } = useTranslation();
  const {
    userId = 1, // 默认使用固定userId
    // engineType = '16k_zh',
    autoStart = false,
    onResult,
    onError
  } = options;

  // 状态管理
  const [status, setStatus] = useState<VoiceRecognitionStatus>('idle');
  const [currentText, setCurrentText] = useState<string>('');
  const [finalText, setFinalText] = useState<string>(''); // 存储已确定的文本
  const [error, setError] = useState<string | null>(null);

  // 新增：缓存状态（使用localStorage持久化）
  const VOICE_INIT_KEY = 'voice_recognition_initialized';
  const [isFirstTimeInit, setIsFirstTimeInit] = useState<boolean>(() => {
    try {
      return !localStorage.getItem(VOICE_INIT_KEY);
    } catch {
      return true;
    }
  });
  const compatibilityCheckedRef = useRef<boolean>(
    (() => {
      try {
        return !!localStorage.getItem('voice_compatibility_checked');
      } catch {
        return false;
      }
    })()
  );
  const lastSignatureRef = useRef<VoiceSignatureResponse['data'] | null>(null);

  // Refs用于保存实例
  const audioRecorderRef = useRef<AudioRecorder | null>(null);
  const websocketRef = useRef<WebSocket | null>(null);
  const signatureRef = useRef<VoiceSignatureResponse['data'] | null>(null);
  const isListeningRef = useRef<boolean>(false);

  // 计算属性
  const isListening = status === 'listening';

  /**
   * 检查浏览器兼容性和设备可用性
   */
  const checkCompatibility = useCallback(async (): Promise<boolean> => {
    try {
      // console.log('🔍 开始检查兼容性和设备可用性...');

      // 执行完整的兼容性诊断
      const diagnostics = await AudioCompatibility.performDiagnostics();

      // 检查基本浏览器支持
      if (!diagnostics.support.getUserMedia) {
        const errorMsg = t('chat.browserNotSupportMic');
        setError(errorMsg);
        onError?.(errorMsg);
        return false;
      }

      if (!diagnostics.support.webSocket) {
        const errorMsg = t('chat.browserNotSupportWebSocket');
        setError(errorMsg);
        onError?.(errorMsg);
        return false;
      }

      if (!diagnostics.support.mediaRecorder) {
        const errorMsg = t('chat.browserNotSupportAudio');
        setError(errorMsg);
        onError?.(errorMsg);
        return false;
      }

      // 检查麦克风设备和权限
      if (!diagnostics.microphone.hasDevices) {
        const errorMsg = diagnostics.microphone.error || '未检测到麦克风设备，请连接麦克风后重试';
        setError(errorMsg);
        onError?.(errorMsg);
        return false;
      }

      if (!diagnostics.microphone.hasPermission) {
        const errorMsg = diagnostics.microphone.error || t('chat.micPermissionDenied');
        setError(errorMsg);
        onError?.(errorMsg);
        return false;
      }

      // 检查音频格式支持
      if (diagnostics.formats.length === 0) {
        const errorMsg = t('chat.noAudioFormat');
        setError(errorMsg);
        onError?.(errorMsg);
        return false;
      }

      // console.log('✅ 兼容性检查通过');
      // console.log('🔍 浏览器信息:', diagnostics.browser);
      // console.log('🔍 支持的音频格式:', diagnostics.formats);
      // console.log('🔍 检测到的麦克风设备:', diagnostics.microphone.devices?.length || 0, '个');

      return true;
    } catch (error) {
      // console.error('🔍 兼容性检查失败:', error);
      // const errorMsg = `兼容性检查失败: ${error instanceof Error ? error.message : t('chat.unknownError')}`;
      const errorMsg = `check compatibility failed: ${error instanceof Error ? error.message : t('chat.unknownError')}`;
      setError(errorMsg);
      onError?.(errorMsg);
      return false;
    }
  }, [onError, t]);

  /**
   * 获取或刷新签名
   */
  const getOrRefreshSignature = useCallback(async () => {
    try {
      // 如果有有效签名，直接使用
      if (signatureRef.current && isSignatureValid(signatureRef.current)) {
        return signatureRef.current;
      }

      // console.log('🔐 获取新的语音识别签名...');
      const response = await getVoiceSignature(userId);
      signatureRef.current = response.data;

      // console.log('🔐 签名获取成功，有效期至:', new Date(response.data.expired * 1000));
      return response.data;
    } catch (err) {
      const errorMsg = `${t('chat.getSignatureFailed')}: ${err instanceof Error ? err.message : t('chat.unknownError')}`;
      console.error('🔐', errorMsg);
      setError(errorMsg);
      onError?.(errorMsg);
      throw err;
    }
  }, [userId, onError, t]);

  /**
   * 初始化WebSocket连接
   */
  const initializeWebSocket = useCallback(async (signature: VoiceSignatureResponse['data']) => {
    return new Promise<WebSocket>((resolve, reject) => {
      try {
        const ws = createVoiceRecognitionWebSocket(signature, {
          onMessage: (data) => {
            // console.log('🎤 语音识别结果:', data);

            // 处理识别结果 - 根据腾讯云API格式
            if (data.result && data.result.voice_text_str) {
              const text = data.result.voice_text_str;
              const sliceType = data.result.slice_type;

              // console.log('🎤 识别结果详情:', {
              //   text,
              //   slice_type: sliceType,
              //   start_time: data.result.start_time,
              //   end_time: data.result.end_time
              // });

              const result: VoiceRecognitionResult = {
                text: text,
                isFinal: sliceType === 2, // slice_type=2表示稳态结果（最终结果）
                confidence: undefined // 腾讯云API不直接提供confidence
              };

              // 根据slice_type更新文本 - 实时累积显示
              if (sliceType === 0) {
                // slice_type=0: 表示一句话开始
                // console.log('🎤 开始新的语音片段');
              } else if (sliceType === 1) {
                // slice_type=1: 表示一句话的中间部分（实时结果） - 实时显示累积文本
                // console.log('🎤 实时识别结果:', text);
                // console.log('🎤 当前固化文本:', finalText);
                setFinalText(prev => {
                  const combinedText = prev + (prev ? ' ' : '') + text;
                  // console.log('🎤 实时累积文本:', combinedText);
                  setCurrentText(combinedText);
                  return prev; // 不更新finalText，保持之前固化的内容
                });
              } else if (sliceType === 2) {
                // slice_type=2: 表示一句话结束（最终结果） - 固化到最终文本
                // console.log('🎤 最终识别结果:', text);
                setFinalText(prev => {
                  const newFinalText = prev + (prev ? ' ' : '') + text;
                  // console.log('🎤 固化累积文本:', newFinalText);
                  setCurrentText(newFinalText);
                  return newFinalText; // 更新finalText，固化当前句子
                });
              }

              onResult?.(result);
            }

            // 处理错误
            if (data.code && data.code !== 0) {
              const errorMsg = `${t('chat.voiceRecognitionError')}: ${data.message || t('chat.unknownError')}`;
              setError(errorMsg);
              onError?.(errorMsg);
            }
          },
          onError: (event) => {
            // console.error('🎤 WebSocket错误:', event);

            // const errorMsg = 'WebSocket连接发生错误';
            const errorMsg = 'WebSocket connection error';
            setError(errorMsg);
            onError?.(errorMsg);
            reject(new Error(errorMsg));
          },
          onClose: (event) => {
            // console.log('🎤 WebSocket连接已关闭:', event.code, event.reason);

            if (event.code !== 1000) { // 非正常关闭
              // let errorMsg = `WebSocket连接异常关闭 (${event.code})`;
              let errorMsg = `WebSocket abnormal close (${event.code})`;

              // 添加具体的错误码说明
              switch (event.code) {
                case 1006:
                  errorMsg += ': 连接异常断开，可能是网络问题、服务器拒绝连接或麦克风权限问题';
                  break;
                case 1002:
                  errorMsg += ': 协议错误，可能是签名或参数格式不正确';
                  break;
                case 1003:
                  errorMsg += ': 数据格式错误';
                  break;
                case 1011:
                  errorMsg += ': 服务器内部错误';
                  break;
                case 1001:
                  errorMsg += ': 端点离开，可能是服务器主动断开';
                  break;
                default:
                  errorMsg += event.reason ? `: ${event.reason}` : ': 未知原因';
              }

              // console.error('🎤 WebSocket异常关闭详情:', { 
              //   code: event.code, 
              //   reason: event.reason, 
              //   wasClean: event.wasClean,
              //   errorMsg 
              // });
              console.error('WebSocket abnormal close details', {
                code: event.code,
                reason: event.reason,
                wasClean: event.wasClean,
                errorMsg
              });

              setError(errorMsg);
              onError?.(errorMsg);
            }

            if (isListeningRef.current) {
              setStatus('idle');
              isListeningRef.current = false;
            }
          }
        });

        // WebSocket连接成功后解析
        ws.addEventListener('open', () => {
          // console.log('🎤 WebSocket连接成功');
          resolve(ws);
        });

        websocketRef.current = ws;
      } catch (err) {
        reject(err);
      }
    });
  }, [onResult, onError, finalText, t]);

  /**
   * 初始化音频录制器
   */
  const initializeAudioRecorder = useCallback(() => {
    return new Promise<AudioRecorder>((resolve, reject) => {
      const recorder = new AudioRecorder(
        {
          sampleRate: 16000, // 腾讯云要求16k采样率
          channels: 1        // 单声道
        },
        {
          onDataAvailable: (audioData) => {
            // 将音频数据发送到WebSocket
            if (websocketRef.current?.readyState === WebSocket.OPEN) {
              // 发送原始音频数据到WebSocket
              // console.log('🎤 发送音频数据，大小:', audioData.byteLength, 'bytes');
              websocketRef.current.send(audioData);
            } else {
              // console.warn('🎤 WebSocket未连接，跳过音频数据发送');
              console.warn('WebSocket is not connected, skip audio data sending');
            }
          },
          onError: (errorMsg) => {
            // console.error('🎤 音频录制错误:', errorMsg);
            console.error('audio recording error',errorMsg);
            setError(errorMsg);
            onError?.(errorMsg);
            reject(new Error(errorMsg));
          },
          onVolumeChange: (volume) => {
            // 可以在这里处理音量变化，比如显示音量条
            if (volume > 0) {
              // console.log('🎤 音量:', volume);
            }
          }
        }
      );

      recorder.initialize()
        .then(() => {
          // console.log('🎤 音频录制器初始化成功');
          audioRecorderRef.current = recorder;
          resolve(recorder);
        })
        .catch(reject);
    });
  }, [onError]);

  /**
   * 开始语音识别（优化版）
   */
  const startListening = useCallback(async (): Promise<void> => {
    try {
      if (isListeningRef.current) {
        // console.log('🎤 已经在监听中，忽略重复调用');
        return;
      }

      setError(null);

      // 优化：区分首次初始化和后续录音
      if (isFirstTimeInit) {
        setStatus('initializing');
        //  console.log('🎤 首次初始化语音识别...');
      } else {
        setStatus('processing'); // 使用processing状态表示快速连接
        //  console.log('🎤 快速启动录音...');
      }

      // 1. 检查兼容性（只在首次检查）
      if (!compatibilityCheckedRef.current) {
        const isCompatible = await checkCompatibility();
        if (!isCompatible) {
          setStatus('error');
          return;
        }
        compatibilityCheckedRef.current = true;
        try {
          localStorage.setItem('voice_compatibility_checked', 'true');
        } catch {
          // 忽略localStorage错误
        }
        //  console.log('🎤 兼容性检查完成（已缓存）');
      }

      // 2. 获取签名（复用有效签名）
      let signature = lastSignatureRef.current;
      if (!signature || !isSignatureValid(signature)) {
        signature = await getOrRefreshSignature();
        lastSignatureRef.current = signature;
        // console.log('🎤 获取新签名');
      } else {
        // console.log('🎤 复用有效签名');
      }

      // 3. 初始化WebSocket连接（必须每次重新建立）
      await initializeWebSocket(signature);

      // 4. 初始化音频录制器（必须每次重新建立）
      await initializeAudioRecorder();

      // 5. 开始录音
      await audioRecorderRef.current?.startRecording();

      // 6. 更新状态
      setStatus('listening');
      isListeningRef.current = true;

      // 标记非首次初始化
      if (isFirstTimeInit) {
        setIsFirstTimeInit(false);
        try {
          localStorage.setItem(VOICE_INIT_KEY, 'true');
        } catch {
          // 忽略localStorage错误
        }
        //  console.log('🎤 首次初始化完成，已保存到localStorage');
      }

      // console.log('🎤 语音识别已启动');
    } catch (err) {
      // console.error('🎤 启动语音识别失败:', err);
      // const errorMsg = `启动语音识别失败: ${err instanceof Error ? err.message : '未知错误'}`;
      const errorMsg = `start voice recognition failed: ${err instanceof Error ? err.message : 'unknown error'}`;
      setError(errorMsg);
      setStatus('error');
      onError?.(errorMsg);

      // 清理资源
      stopListening();
    }
  }, [checkCompatibility, getOrRefreshSignature, initializeWebSocket, initializeAudioRecorder, onError, isFirstTimeInit, t]);

  /**
   * 停止语音识别
   */
  const stopListening = useCallback((): void => {
    // console.log('🎤 停止语音识别...');

    // 停止录音
    audioRecorderRef.current?.stopRecording();
    audioRecorderRef.current?.destroy();
    audioRecorderRef.current = null;

    // 发送结束信号并关闭WebSocket
    if (websocketRef.current?.readyState === WebSocket.OPEN) {
      // 根据腾讯云API要求发送结束信号
      websocketRef.current.send(JSON.stringify({ type: "end" }));
      setTimeout(() => {
        if (websocketRef.current?.readyState === WebSocket.OPEN) {
          websocketRef.current.close();
        }
        websocketRef.current = null;
      }, 100); // 等待100ms确保结束信号发送成功
    } else {
      websocketRef.current = null;
    }

    // 更新状态
    setStatus('idle');
    isListeningRef.current = false;

    // console.log('🎤 语音识别已停止');
  }, []);

  /**
   * 重置文本
   */
  const resetText = useCallback((): void => {
    setCurrentText('');
    setFinalText('');
  }, []);

  /**
   * 获取清理后的文本（移除临时标记等）
   */
  const getCleanText = useCallback((): string => {
    return currentText.trim();
  }, [currentText]);

  // 组件卸载时清理资源
  useEffect(() => {
    return () => {
      stopListening();
    };
  }, [stopListening]);

  // 自动启动
  useEffect(() => {
    if (autoStart && status === 'idle') {
      startListening();
    }
  }, [autoStart, status, startListening]);

  return {
    status,
    isListening,
    currentText: getCleanText(),
    error,
    startListening,
    stopListening,
    resetText
  };
}; 